/**
 * 给定数组L、R、C，要求最小化 SIGMA{Ci * (Ri - Li)}
 * 对于任意4个数 Li,Lj,Ri,Rj，可以构成两个区间
 * 如果构成的区间不相交，显然将小C赋给较长的区间，大C赋给短的
 * 如果相交，可以发现，仍然要将大C赋给较短的区间
 * 因此整个就是贪心，将C数组降序排列，不断的找到当前最小的(R - L)，累加即可
 * 
 * 首先对每个Li，找到比它大的且最近的Rj，将(i, j)加入优先级队列
 * 每一次，取出头节点(i, j)：如果flag[j]没有被使用，则该(Rj - Li)就是当前最小的，与当前c匹配即可
 * 如果flag[j]已经被使用，则需要从 j+1 开始往后找，找到第一个为0的位置，记作k，将(i, k)入队即可
 * 一个简单的循环找k会导致超时。但是很明显这具有二分的特征，而需要使用二分则需要区间和
 * 因此用树状数组维护flag即可
 * 
 * 但实际上不需要实时安排C，只需将所有短的区间求出来排序，再与C结合即可
 * 用类似单调栈很容易处理
 * 对每一个Ri：
 *    将Lj入栈，直到Lj>Ri为止，此时(top, Ri)为一个区间
 *    处理下一个Ri
 */
#include <bits/stdc++.h>
using namespace std;

#include <bits/extc++.h>
using namespace __gnu_pbds;

#include <bits/stdc++.h>
using namespace std;

#include <bits/stdc++.h>
using namespace std;

struct FenwickTree{ // 树状数组

using value_type = long long int;
using vec_type = vector<value_type>;

int n;
vec_type c;

FenwickTree() = default;

static int lowbit(int x){return x & -x;}

void init(int nn){this->c.assign((this->n=nn) + 1, 0);}

void modify(int pos, value_type delta){
    for(int i=pos;i<=this->n;i+=lowbit(i)) this->c[i] += delta;
}

value_type query(int pos)const{
    value_type ans = 0;
    for(int i=pos;i;i-=lowbit(i)) ans += this->c[i];
    return ans;
}

value_type query(int s, int e)const{return this->query(e) - this->query(s - 1);}

}Bt;


using llt = long long;
using pii = pair<int, int>;
using vi = vector<int>;
using vvi = vector<vi>;

int N;
vector<llt> L, R, W;

__gnu_pbds::priority_queue<pii, function<bool(const pii&, const pii&)>> Q([](const pii & a, const pii & b){
    auto aa = R[a.second] - L[a.first];
    auto bb = R[b.second] - L[b.first];
    return aa > bb;
});

int get(int start){
    int left = start, right = N, mid;
    do{
        mid = (left + right) >> 1;
        if(Bt.query(start, mid) == mid - start + 1) left = mid + 1;
        else right = mid - 1;     
    }while(left <= right);
    return left;
}

llt proc(){
    Q.clear();
    sort(L.begin(), L.end());
    sort(R.begin(), R.end());
    sort(W.begin(), W.end(), greater<llt>());
    for(int i=0;i<N;++i){
        auto p = lower_bound(R.begin(), R.end(), L[i]) - R.begin();
        Q.push({i, p});
    }

    llt ans = 0;
    vi lflag(N, 0);
    Bt.init(N);
    for(auto w : W){
        while(1){
            auto h = Q.top();
            if(Bt.query(h.second + 1, h.second + 1)){
                Q.pop();
                int k = get(h.second + 2) - 1;
                assert(k != N);
                Q.push({h.first, k});
            }else{
                break;
            } 
        }
        auto h = Q.top(); Q.pop();
        assert(lflag[h.first] == 0);
        ans += w * (R[h.second] - L[h.first]);
        lflag[h.first] = 1;
        Bt.modify(h.second + 1, 1);
    }
    return ans;
}

int main(){
#ifndef ONLINE_JUDGE
    freopen("z.txt", "r", stdin);
#endif
    ios::sync_with_stdio(false);cin.tie(nullptr);cout.tie(0);
    int nofkase = 1;
    cin >> nofkase;
    while(nofkase--){
        cin >> N;
        L.assign(N, 0);
        R.assign(N, 0);
        W.assign(N, 0);
        for(auto & i : L) cin >> i;
        for(auto & i : R) cin >> i;
        for(auto & i : W) cin >> i;
        cout << proc() << "\n";
    }
    return 0;
}